import pytest  # used for our unit tests
# import the function and the HookUsage type from the real module under test
from codeflash.languages.javascript.frameworks.react.context import (
    HookUsage, _extract_hook_usages)

def test_no_hooks_returns_empty_list():
    # Very simple source with no hook-like identifiers -> expect empty list
    src = "function Component() { const x = 1; return x; }"
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 4.52μs -> 4.80μs (5.86% slower)

def test_single_hook_no_deps():
    # Single hook call with simple argument, no dependency array
    src = "const [s, setS] = useState(0);"
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 8.19μs -> 7.36μs (11.1% faster)
    hu = result[0]

def test_single_hook_with_empty_deps():
    # Hook with an explicit empty dependency array
    src = "useEffect(() => { doSomething(); }, [])"
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 10.3μs -> 10.6μs (2.65% slower)
    hu = result[0]

def test_single_hook_with_multiple_deps():
    # Hook with several comma-separated dependencies
    src = "useEffect(() => { a(); }, [a, b, c])"
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 10.3μs -> 10.5μs (2.67% slower)
    hu = result[0]

def test_hook_with_nested_parentheses_and_deps():
    # Ensure nested parentheses in the first argument do not break detection
    src = "useMemo(() => (x) => (y) => y + x, [dep])"
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 10.9μs -> 10.9μs (0.558% slower)
    hu = result[0]

def test_multiple_hooks_mixed_in_one_source():
    # Multiple hooks of different kinds in a single source text,
    # including one with deps and one without
    src = """
    function C() {
        const [s] = useState(0);
        useEffect(() => { console.log(s); }, [s]);
        useRef(null);
    }
    """
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 15.5μs -> 15.1μs (2.39% faster)

def test_hook_name_case_sensitivity_and_digits():
    # The regex requires an uppercase letter after 'use'. Lowercase should not match.
    src = "useeffect(); useA1('x');"
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 8.22μs -> 7.36μs (11.7% faster)

def test_dependency_array_on_next_line_and_spaces():
    # Dependency array may be on the next line or with extra spaces
    src = "useEffect(fn,   \n   [dep]  )"
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 9.60μs -> 9.75μs (1.54% slower)
    hu = result[0]

def test_false_positive_array_in_inner_argument_counts_as_deps():
    # The heuristic looks for a trailing ']' before the closing paren.
    # If an inner argument contains an array (but it's not the last arg),
    # the heuristic may still treat it as the dependency array.
    # This test documents that behavior: the function will mark has_dependency_array True.
    src = "useCustom(doSomething([a,b]))"
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 8.87μs -> 8.57μs (3.50% faster)
    hu = result[0]

def test_no_match_for_lowercase_after_use():
    # Confirm that 'use' followed by a lowercase character is not matched
    src = "const x = usevalue(1);"
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 4.24μs -> 4.37μs (2.98% slower)

def test_empty_input_returns_empty_list():
    # Edge case: empty source string should return no hooks
    codeflash_output = _extract_hook_usages(""); result = codeflash_output # 3.06μs -> 3.15μs (2.86% slower)

def test_large_number_of_hooks_performance_and_correctness():
    # Construct a large source string with 1000 simple hook calls (no deps)
    count = 1000
    # Use the correct capitalization 'useState' which the regex will match
    src = ";".join("useState({})".format(i) for i in range(count))
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 1.42ms -> 994μs (42.9% faster)

def test_large_mixed_hooks_with_deps_and_nested_parens():
    # Build a large source alternating hooks with and without deps,
    # and some with nested parentheses to ensure the parser remains correct.
    items = []
    n = 300  # smaller than 1000 but still large and exercises loops
    for i in range(n):
        if i % 3 == 0:
            # hook with deps
            items.append(f"useEffect(() => {{ fn({i}); }}, [d{i}, d{i+1}])")
        elif i % 3 == 1:
            # hook with nested parentheses but no deps
            items.append(f"useMemo(() => ((x) => x + {i})())")
        else:
            # simple hook
            items.append(f"useRef(null)")
    src = ";\n".join(items)
    codeflash_output = _extract_hook_usages(src); result = codeflash_output # 706μs -> 749μs (5.70% slower)
    # Validate a few sampled positions for expected properties
    for i in range(0, n, 50):
        hu = result[i]
        if i % 3 == 0:
            pass
        elif i % 3 == 1:
            pass
        else:
            pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from dataclasses import dataclass

# imports
import pytest
from codeflash.languages.javascript.frameworks.react.context import \
    _extract_hook_usages

def test_single_hook_with_dependency_array():
    """Test extraction of a single hook with a dependency array."""
    source = "useState(initialValue, [value])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.8μs -> 10.8μs (0.566% faster)

def test_single_hook_without_dependency_array():
    """Test extraction of a hook without a dependency array."""
    source = "useEffect(() => { console.log('mounted'); })"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.2μs -> 10.3μs (0.594% slower)

def test_multiple_hooks_mixed():
    """Test extraction of multiple hooks with mixed dependency array presence."""
    source = "useState(0, []) useEffect(() => {}) useContext(MyContext)"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 13.6μs -> 13.0μs (4.23% faster)

def test_hook_with_multiple_dependencies():
    """Test extraction of a hook with multiple dependencies."""
    source = "useState(initialValue, [dep1, dep2, dep3])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.5μs -> 11.0μs (4.01% slower)

def test_hook_with_complex_dependency_expressions():
    """Test extraction of a hook with complex dependency expressions."""
    source = "useCallback(() => {}, [state.prop, obj.method(), getValue()])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 11.7μs -> 12.5μs (6.57% slower)

def test_hook_in_assignment():
    """Test extraction of a hook used in an assignment."""
    source = "const state = useState(0, [counter])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.55μs -> 9.66μs (1.14% slower)

def test_hook_with_whitespace_variations():
    """Test extraction of hooks with varying whitespace."""
    source = "useEffect  (  callback  , [ dep ] )"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.94μs -> 10.4μs (4.71% slower)

def test_builtin_function_not_matched():
    """Test that built-in functions like useState are not confused with user functions."""
    source = "useState(0) versus myFunction()"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 8.14μs -> 7.49μs (8.57% faster)

def test_hook_with_string_literals_containing_parens():
    """Test extraction when hook dependencies contain string literals with parentheses."""
    source = "useMemo(() => compute(), ['key(value)'])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.6μs -> 10.8μs (2.50% slower)

def test_custom_hook_extraction():
    """Test extraction of custom hooks following the useXxx naming convention."""
    source = "useCustomHook(param1, [dep1, dep2])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.62μs -> 9.84μs (2.24% slower)

def test_empty_source_string():
    """Test extraction from an empty source string."""
    source = ""
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 3.01μs -> 3.30μs (8.80% slower)

def test_source_with_no_hooks():
    """Test extraction from source containing no hooks."""
    source = "const x = 42; function regularFunction() { return x; }"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 4.40μs -> 4.78μs (7.97% slower)

def test_hook_at_end_of_string_without_closing_paren():
    """Test extraction when hook call is incomplete at end of string."""
    source = "useState("
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 6.66μs -> 6.36μs (4.73% faster)

def test_hook_with_empty_dependency_array():
    """Test extraction of a hook with explicitly empty dependency array."""
    source = "useEffect(callback, [])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 8.93μs -> 9.06μs (1.44% slower)

def test_hook_with_only_whitespace_in_dependency_array():
    """Test extraction of a hook with only whitespace inside dependency array."""
    source = "useEffect(callback, [   ])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.37μs -> 9.27μs (1.09% faster)

def test_nested_function_calls_in_hook():
    """Test extraction when hook arguments contain nested function calls."""
    source = "useState(getValue(getInitialValue()))"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.34μs -> 9.29μs (0.538% faster)

def test_hook_with_nested_arrays_in_dependencies():
    """Test extraction when dependency array contains nested arrays."""
    source = "useCallback(fn, [[nested, array], item])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.3μs -> 10.5μs (2.37% slower)

def test_hook_name_case_sensitivity():
    """Test that hook matching respects case sensitivity."""
    source = "usestate(0) useState(0)"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 7.82μs -> 7.34μs (6.54% faster)

def test_hook_not_matched_without_capital_letter_after_use():
    """Test that use1stHook pattern is correctly identified."""
    source = "use1stHook(value, [dep])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 4.02μs -> 4.33μs (7.16% slower)

def test_hook_with_no_arguments():
    """Test extraction of a hook called with no arguments."""
    source = "useContext()"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 7.35μs -> 6.63μs (10.9% faster)

def test_multiple_hooks_on_same_line():
    """Test extraction of multiple hooks on the same line with various patterns."""
    source = "const a = useState(0, [x]); const b = useEffect(() => {}, [y, z])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 13.6μs -> 13.4μs (1.73% faster)

def test_hook_immediately_followed_by_another():
    """Test extraction when hooks are written consecutively."""
    source = "useState(0, [])useEffect(() => {}, [x])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 12.3μs -> 12.1μs (1.99% faster)

def test_hook_with_arrow_function_in_dependencies():
    """Test extraction when dependency array contains arrow functions (unusual but possible)."""
    source = "useCallback(() => {}, [() => null, other])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.2μs -> 11.0μs (6.93% slower)

def test_hook_with_object_literal_in_dependencies():
    """Test extraction when dependency array contains object literals."""
    source = "useMemo(() => {}, [{key: value}, other])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.6μs -> 11.1μs (4.95% slower)

def test_hook_pattern_at_word_boundary():
    """Test that hook pattern respects word boundaries."""
    source = "myuseState(0) useStateManager(0) useState(0)"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.1μs -> 9.27μs (9.18% faster)

def test_source_with_only_whitespace():
    """Test extraction from source containing only whitespace."""
    source = "   \n\t  \r\n  "
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 3.80μs -> 4.05μs (6.18% slower)

def test_hook_with_comment_in_dependencies():
    """Test extraction when source contains comments (naive parser doesn't strip them)."""
    source = "useState(0, [value /* important */])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.3μs -> 10.6μs (3.02% slower)

def test_single_character_hook_name():
    """Test that hook names must have at least 2 characters after 'use'."""
    source = "useA()"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 7.29μs -> 6.29μs (15.9% faster)

def test_very_long_hook_name():
    """Test extraction of a hook with an extremely long name."""
    long_hook_name = "use" + "VeryLongCustomHookNameWithManyCharacters" * 5
    source = f"{long_hook_name}()"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 7.75μs -> 6.87μs (12.8% faster)

def test_dependency_array_with_trailing_comma():
    """Test extraction of dependency array with trailing comma."""
    source = "useEffect(callback, [dep1, dep2,])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.93μs -> 10.3μs (3.98% slower)

def test_hook_with_destructured_arguments():
    """Test extraction of hook with destructured arguments."""
    source = "useReducer(({ state }, action) => {}, initialState, [init])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 11.3μs -> 12.1μs (6.52% slower)

def test_hook_with_spread_operator_in_dependencies():
    """Test extraction when dependency array uses spread operator."""
    source = "useMemo(() => {}, [...dependencies])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.1μs -> 10.5μs (3.35% slower)

def test_hook_without_dependency_array_with_trailing_comma():
    """Test hook call with trailing comma but no dependency array."""
    source = "useState(0, callback,)"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 8.34μs -> 8.02μs (3.99% faster)

def test_many_hooks_in_single_source():
    """Test extraction of 100 hooks from a single source string."""
    # Build a source with 100 different hooks
    hooks_list = [f"useHook{i}(value, [dep{i}])" for i in range(100)]
    source = " ".join(hooks_list)
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 216μs -> 222μs (2.79% slower)
    # Verify all hooks were extracted correctly
    for i, hook in enumerate(result):
        pass

def test_hooks_with_many_dependencies():
    """Test extraction of hooks with very large dependency arrays."""
    # Create a dependency array with 100 items
    dependencies = ", ".join([f"dep{i}" for i in range(100)])
    source = f"useEffect(callback, [{dependencies}])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 43.4μs -> 56.7μs (23.5% slower)

def test_deeply_nested_function_calls():
    """Test extraction from source with deeply nested function calls."""
    # Create 100 levels of nested function calls
    nested = "value"
    for i in range(100):
        nested = f"func{i}({nested})"
    source = f"useState({nested}, [state])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 52.1μs -> 67.0μs (22.4% slower)

def test_large_source_with_mixed_content():
    """Test extraction from a large source file with mixed content."""
    # Build a large source with hooks, comments, and other code
    lines = []
    # Add some regular code
    for i in range(50):
        lines.append(f"const var{i} = {i};")
    # Add hooks scattered throughout
    for i in range(50):
        if i % 2 == 0:
            lines.append(f"const hook{i} = useCustomHook{i}(param, [dep{i}]);")
        else:
            lines.append(f"useEffect{i}(() => {{}}, [dep{i}, other{i}])")
    # Add more regular code
    for i in range(50):
        lines.append(f"function func{i}() {{ return var{i}; }}")
    
    source = "\n".join(lines)
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 164μs -> 176μs (6.57% slower)

def test_hooks_with_very_long_dependency_expressions():
    """Test extraction when dependencies contain very long expressions."""
    # Build a long complex dependency
    complex_dep = "obj.method().prop.anotherProp.deepMethod().value"
    source = f"useMemo(() => {{}}, [{complex_dep}])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 12.3μs -> 13.4μs (8.57% slower)

def test_source_with_1000_character_long_line():
    """Test extraction from source with very long lines."""
    # Create a single hook with many dependencies
    deps = ", ".join([f"dep{i}" for i in range(250)])
    source = f"useHook({' ' * 500}[{deps}])"
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 127μs -> 172μs (25.9% slower)

def test_alternating_hooks_and_non_hooks():
    """Test extraction from source alternating between hooks and non-hook calls."""
    # Build source with alternating pattern
    parts = []
    for i in range(100):
        if i % 2 == 0:
            parts.append(f"useHook{i}(val, [dep])")
        else:
            parts.append(f"regularFunc{i}(val)")
    source = " ".join(parts)
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 114μs -> 112μs (1.37% faster)
    # Verify all found items are hooks
    for hook in result:
        pass

def test_hooks_with_multiline_dependency_arrays():
    """Test extraction when dependency arrays span multiple lines."""
    source = """
    useEffect(
        callback,
        [
            dep1,
            dep2,
            dep3,
            dep4,
            dep5
        ]
    )
    """
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 15.6μs -> 18.5μs (15.7% slower)

def test_performance_with_many_non_matching_patterns():
    """Test performance when source contains many similar but non-matching patterns."""
    # Create source with many patterns that almost match but don't
    parts = []
    for i in range(500):
        parts.append(f"notuse{i}()")
        parts.append(f"use{i}()")  # Lowercase after 'use'
        parts.append(f"useHook{i}()")  # Actual matching hooks
    source = " ".join(parts)
    codeflash_output = _extract_hook_usages(source); result = codeflash_output # 806μs -> 515μs (56.3% faster)
    for hook in result:
        pass

def test_extraction_consistency_with_repeated_source():
    """Test that extraction produces consistent results when run on same source multiple times."""
    source = "useState(0, [x, y]) useEffect(() => {}, [z])"
    # Run extraction three times
    codeflash_output = _extract_hook_usages(source); result1 = codeflash_output # 13.4μs -> 13.3μs (0.609% faster)
    codeflash_output = _extract_hook_usages(source); result2 = codeflash_output # 7.36μs -> 7.33μs (0.423% faster)
    codeflash_output = _extract_hook_usages(source); result3 = codeflash_output # 5.80μs -> 5.84μs (0.685% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from codeflash.languages.javascript.frameworks.react.benchmarking import (
    RenderBenchmark, compare_render_benchmarks)
# import the real classes and function under test from the package
from codeflash.languages.javascript.parse import RenderProfile

def test_empty_lists_return_none():
    # If either input list is empty the function should return None
    # Prepare an example profile to use in one of the parameters
    rp = RenderProfile("Button", "mount", 12.0, 10.0, 1)
    # original empty
    codeflash_output = compare_render_benchmarks([], [rp]); res = codeflash_output # 410ns -> 431ns (4.87% slower)
    # optimized empty
    codeflash_output = compare_render_benchmarks([rp], []); res = codeflash_output # 300ns -> 290ns (3.45% faster)
    # both empty
    codeflash_output = compare_render_benchmarks([], []); res = codeflash_output # 170ns -> 170ns (0.000% faster)

def test_single_profile_each_basic_aggregation():
    # Simple case: one original and one optimized profile
    orig = RenderProfile("MyComponent", "mount", 25.5, 20.0, 2)
    opt = RenderProfile("MyComponent", "update", 10.0, 9.0, 1)
    codeflash_output = compare_render_benchmarks([orig], [opt]); bench = codeflash_output # 6.04μs -> 2.96μs (104% faster)

def test_multiple_profiles_aggregation_and_component_name_choice():
    # Multiple original profiles: check max(render_count) and average(actual_duration_ms)
    originals = [
        RenderProfile("Primary", "mount", 10.0, 9.0, 1),
        RenderProfile("Primary-ALT", "update", 30.0, 28.0, 3),
        RenderProfile("Primary", "update", 20.0, 19.0, 2),
    ]
    # Multiple optimized profiles with different component names to ensure original[0] wins
    optimized = [
        RenderProfile("Other", "update", 5.0, 5.0, 2),
        RenderProfile("Other", "update", 15.0, 14.0, 4),
    ]
    codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 6.22μs -> 3.07μs (103% faster)

def test_zero_and_negative_durations_and_counts():
    # Ensure function handles zero and negative durations gracefully (mathematical average)
    originals = [
        RenderProfile("EdgeCase", "mount", 0.0, 0.0, 0),
        RenderProfile("EdgeCase", "update", -5.0, -5.0, 0),
    ]
    optimized = [
        RenderProfile("EdgeCase", "mount", 0.0, 0.0, 0),
    ]
    codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 5.70μs -> 2.81μs (103% faster)

def test_phase_values_do_not_affect_aggregation():
    # Different phase strings should not affect aggregation logic
    originals = [
        RenderProfile("PhaseComp", "mount", 2.0, 1.0, 1),
        RenderProfile("PhaseComp", "update", 8.0, 7.0, 2),
    ]
    optimized = [
        RenderProfile("PhaseComp", "mount", 5.0, 4.0, 1),
        RenderProfile("PhaseComp", "update", 7.0, 6.0, 3),
    ]
    codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 5.80μs -> 2.82μs (106% faster)

def test_component_name_with_special_characters():
    # Component names containing punctuation and whitespace are preserved
    name = "Comp v2.0 - test_case/α"  # includes punctuation and non-ascii character
    originals = [RenderProfile(name, "mount", 3.0, 3.0, 1)]
    optimized = [RenderProfile(name, "update", 1.0, 1.0, 1)]
    codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 5.40μs -> 2.57μs (110% faster)

def test_large_scale_aggregation_1000_elements_original_and_optimized():
    # Create 1000 original profiles with durations 1..1000 and render_count equal to the index
    originals = [
        RenderProfile("BigComp", "update", float(i), 0.0, i) for i in range(1, 1001)
    ]
    # Create 1000 optimized profiles with durations 1001..2000 and render_count equal to index+1000
    optimized = [
        RenderProfile("BigComp", "update", float(1000 + i), 0.0, 1000 + i)
        for i in range(1, 1001)
    ]
    codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 128μs -> 108μs (19.0% faster)

def test_large_scale_with_repeated_values_and_max_check():
    # 1000 items where render_count cycles but we ensure a known max exists
    # Use render_count = i % 37 and include one item with a much larger count to set the max
    originals = [
        RenderProfile("CycleComp", "mount", float(i % 10), 0.0, i % 37) for i in range(1000)
    ]
    # Insert one outlier with very large render_count at the beginning (to also test component_name)
    originals.insert(0, RenderProfile("CycleComp", "mount", 0.0, 0.0, 9999))
    optimized = [
        RenderProfile("CycleComp", "update", 5.0, 0.0, 0) for _ in range(1000)
    ]
    codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 126μs -> 86.8μs (46.0% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest
from codeflash.languages.javascript.frameworks.react.benchmarking import (
    RenderBenchmark, compare_render_benchmarks)
from codeflash.languages.javascript.parse import RenderProfile

def test_compare_render_benchmarks_basic_single_profile_each():
    """Test basic comparison with one profile in each list."""
    original = [
        RenderProfile(
            component_name="Button",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=3.0,
            render_count=1,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="Button",
            phase="mount",
            actual_duration_ms=3.0,
            base_duration_ms=2.0,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.59μs -> 2.75μs (103% faster)

def test_compare_render_benchmarks_multiple_profiles_both_lists():
    """Test comparison with multiple profiles in each list."""
    original = [
        RenderProfile(
            component_name="Modal",
            phase="mount",
            actual_duration_ms=10.0,
            base_duration_ms=8.0,
            render_count=2,
        ),
        RenderProfile(
            component_name="Modal",
            phase="update",
            actual_duration_ms=8.0,
            base_duration_ms=6.0,
            render_count=3,
        ),
    ]
    optimized = [
        RenderProfile(
            component_name="Modal",
            phase="mount",
            actual_duration_ms=6.0,
            base_duration_ms=5.0,
            render_count=2,
        ),
        RenderProfile(
            component_name="Modal",
            phase="update",
            actual_duration_ms=4.0,
            base_duration_ms=3.0,
            render_count=2,
        ),
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.91μs -> 2.87μs (106% faster)

def test_compare_render_benchmarks_uses_first_component_name():
    """Test that the function uses the first profile's component name."""
    original = [
        RenderProfile(
            component_name="Component1",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=4.0,
            render_count=1,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="Component1",
            phase="mount",
            actual_duration_ms=3.0,
            base_duration_ms=2.0,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.30μs -> 2.69μs (96.7% faster)

def test_compare_render_benchmarks_returns_render_benchmark_type():
    """Test that the return type is RenderBenchmark."""
    original = [
        RenderProfile(
            component_name="Test",
            phase="mount",
            actual_duration_ms=1.0,
            base_duration_ms=1.0,
            render_count=1,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="Test",
            phase="mount",
            actual_duration_ms=1.0,
            base_duration_ms=1.0,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.24μs -> 2.63μs (98.9% faster)

def test_compare_render_benchmarks_zero_duration_values():
    """Test with zero duration values."""
    original = [
        RenderProfile(
            component_name="Fast",
            phase="mount",
            actual_duration_ms=0.0,
            base_duration_ms=0.0,
            render_count=1,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="Fast",
            phase="mount",
            actual_duration_ms=0.0,
            base_duration_ms=0.0,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.21μs -> 2.57μs (102% faster)

def test_compare_render_benchmarks_very_small_float_values():
    """Test with very small floating point values."""
    original = [
        RenderProfile(
            component_name="Micro",
            phase="mount",
            actual_duration_ms=0.001,
            base_duration_ms=0.001,
            render_count=1,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="Micro",
            phase="mount",
            actual_duration_ms=0.0005,
            base_duration_ms=0.0005,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.28μs -> 2.60μs (103% faster)

def test_compare_render_benchmarks_large_duration_values():
    """Test with very large duration values."""
    original = [
        RenderProfile(
            component_name="Slow",
            phase="mount",
            actual_duration_ms=10000.5,
            base_duration_ms=9999.5,
            render_count=1,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="Slow",
            phase="mount",
            actual_duration_ms=5000.25,
            base_duration_ms=4999.75,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.22μs -> 2.53μs (106% faster)

def test_compare_render_benchmarks_high_render_count():
    """Test with high render counts."""
    original = [
        RenderProfile(
            component_name="Expensive",
            phase="mount",
            actual_duration_ms=2.0,
            base_duration_ms=1.0,
            render_count=1000,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="Expensive",
            phase="mount",
            actual_duration_ms=1.0,
            base_duration_ms=0.5,
            render_count=500,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.27μs -> 2.60μs (102% faster)

def test_compare_render_benchmarks_empty_original_list_returns_none():
    """Test that empty original_profiles list returns None."""
    original = []
    optimized = [
        RenderProfile(
            component_name="Button",
            phase="mount",
            actual_duration_ms=3.0,
            base_duration_ms=2.0,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 431ns -> 411ns (4.87% faster)

def test_compare_render_benchmarks_empty_optimized_list_returns_none():
    """Test that empty optimized_profiles list returns None."""
    original = [
        RenderProfile(
            component_name="Button",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=3.0,
            render_count=1,
        )
    ]
    optimized = []
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 421ns -> 441ns (4.54% slower)

def test_compare_render_benchmarks_both_lists_empty_returns_none():
    """Test that both lists being empty returns None."""
    original = []
    optimized = []
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 411ns -> 400ns (2.75% faster)

def test_compare_render_benchmarks_special_characters_in_component_name():
    """Test with special characters in component name."""
    original = [
        RenderProfile(
            component_name="Button-Primary_V2.0",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=4.0,
            render_count=1,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="Button-Primary_V2.0",
            phase="mount",
            actual_duration_ms=3.0,
            base_duration_ms=2.0,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.64μs -> 2.77μs (104% faster)

def test_compare_render_benchmarks_unicode_component_name():
    """Test with unicode characters in component name."""
    original = [
        RenderProfile(
            component_name="按钮",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=4.0,
            render_count=1,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="按钮",
            phase="mount",
            actual_duration_ms=3.0,
            base_duration_ms=2.0,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.32μs -> 2.60μs (104% faster)

def test_compare_render_benchmarks_render_count_zero():
    """Test with zero render count."""
    original = [
        RenderProfile(
            component_name="Test",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=4.0,
            render_count=0,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="Test",
            phase="mount",
            actual_duration_ms=3.0,
            base_duration_ms=2.0,
            render_count=0,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.25μs -> 2.60μs (102% faster)

def test_compare_render_benchmarks_negative_duration_values():
    """Test with negative duration values (edge case, though unlikely in real use)."""
    original = [
        RenderProfile(
            component_name="Negative",
            phase="mount",
            actual_duration_ms=-1.0,
            base_duration_ms=-1.0,
            render_count=1,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="Negative",
            phase="mount",
            actual_duration_ms=-0.5,
            base_duration_ms=-0.5,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.24μs -> 2.62μs (99.6% faster)

def test_compare_render_benchmarks_max_render_count_used():
    """Test that max render_count is correctly selected."""
    original = [
        RenderProfile(
            component_name="MaxTest",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=4.0,
            render_count=10,
        ),
        RenderProfile(
            component_name="MaxTest",
            phase="update",
            actual_duration_ms=3.0,
            base_duration_ms=2.0,
            render_count=50,
        ),
        RenderProfile(
            component_name="MaxTest",
            phase="update",
            actual_duration_ms=2.0,
            base_duration_ms=1.0,
            render_count=30,
        ),
    ]
    optimized = [
        RenderProfile(
            component_name="MaxTest",
            phase="mount",
            actual_duration_ms=2.0,
            base_duration_ms=1.0,
            render_count=5,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.75μs -> 2.90μs (98.0% faster)

def test_compare_render_benchmarks_average_duration_calculation():
    """Test that average duration is correctly calculated."""
    original = [
        RenderProfile(
            component_name="Avg",
            phase="mount",
            actual_duration_ms=10.0,
            base_duration_ms=8.0,
            render_count=1,
        ),
        RenderProfile(
            component_name="Avg",
            phase="update",
            actual_duration_ms=20.0,
            base_duration_ms=16.0,
            render_count=2,
        ),
        RenderProfile(
            component_name="Avg",
            phase="update",
            actual_duration_ms=30.0,
            base_duration_ms=24.0,
            render_count=3,
        ),
    ]
    optimized = [
        RenderProfile(
            component_name="Avg",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=4.0,
            render_count=1,
        ),
        RenderProfile(
            component_name="Avg",
            phase="update",
            actual_duration_ms=10.0,
            base_duration_ms=8.0,
            render_count=2,
        ),
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.78μs -> 2.87μs (102% faster)

def test_compare_render_benchmarks_different_phases_handled():
    """Test that different phase values are handled correctly."""
    original = [
        RenderProfile(
            component_name="Component",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=4.0,
            render_count=1,
        ),
        RenderProfile(
            component_name="Component",
            phase="update",
            actual_duration_ms=3.0,
            base_duration_ms=2.0,
            render_count=1,
        ),
    ]
    optimized = [
        RenderProfile(
            component_name="Component",
            phase="mount",
            actual_duration_ms=2.0,
            base_duration_ms=1.0,
            render_count=1,
        ),
        RenderProfile(
            component_name="Component",
            phase="update",
            actual_duration_ms=1.0,
            base_duration_ms=0.5,
            render_count=1,
        ),
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.68μs -> 2.79μs (104% faster)

def test_compare_render_benchmarks_single_very_long_list_original():
    """Test with many profiles in original list."""
    original = [
        RenderProfile(
            component_name="LongList",
            phase="mount" if i % 2 == 0 else "update",
            actual_duration_ms=float(i),
            base_duration_ms=float(i - 1),
            render_count=i + 1,
        )
        for i in range(1, 11)
    ]
    optimized = [
        RenderProfile(
            component_name="LongList",
            phase="mount",
            actual_duration_ms=1.0,
            base_duration_ms=1.0,
            render_count=1,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 6.16μs -> 3.24μs (90.4% faster)
    # Average: (1 + 2 + 3 + ... + 10) / 10 = 5.5
    expected_avg = sum(range(1, 11)) / 10

def test_compare_render_benchmarks_three_profiles_average():
    """Test average calculation with exactly three profiles."""
    original = [
        RenderProfile(
            component_name="Three",
            phase="mount",
            actual_duration_ms=9.0,
            base_duration_ms=8.0,
            render_count=1,
        ),
        RenderProfile(
            component_name="Three",
            phase="update",
            actual_duration_ms=12.0,
            base_duration_ms=11.0,
            render_count=2,
        ),
        RenderProfile(
            component_name="Three",
            phase="update",
            actual_duration_ms=15.0,
            base_duration_ms=14.0,
            render_count=3,
        ),
    ]
    optimized = [
        RenderProfile(
            component_name="Three",
            phase="mount",
            actual_duration_ms=3.0,
            base_duration_ms=2.0,
            render_count=1,
        ),
        RenderProfile(
            component_name="Three",
            phase="update",
            actual_duration_ms=6.0,
            base_duration_ms=5.0,
            render_count=2,
        ),
        RenderProfile(
            component_name="Three",
            phase="update",
            actual_duration_ms=9.0,
            base_duration_ms=8.0,
            render_count=3,
        ),
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.69μs -> 2.96μs (92.6% faster)

def test_compare_render_benchmarks_many_profiles_original():
    """Test with 100 profiles in original list."""
    original = [
        RenderProfile(
            component_name="LargeComponent",
            phase="mount" if i % 2 == 0 else "update",
            actual_duration_ms=float(i % 50 + 1),
            base_duration_ms=float((i % 50)),
            render_count=(i % 100) + 1,
        )
        for i in range(100)
    ]
    optimized = [
        RenderProfile(
            component_name="LargeComponent",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=4.0,
            render_count=10,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 12.6μs -> 8.00μs (57.4% faster)
    # Verify that the aggregation works correctly
    expected_max_render = max((i % 100) + 1 for i in range(100))

def test_compare_render_benchmarks_many_profiles_optimized():
    """Test with 100 profiles in optimized list."""
    original = [
        RenderProfile(
            component_name="OptimizedComponent",
            phase="mount",
            actual_duration_ms=10.0,
            base_duration_ms=8.0,
            render_count=50,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="OptimizedComponent",
            phase="mount" if i % 2 == 0 else "update",
            actual_duration_ms=float(i % 30 + 1),
            base_duration_ms=float((i % 30)),
            render_count=(i % 80) + 1,
        )
        for i in range(100)
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 12.3μs -> 7.86μs (56.2% faster)
    # Verify that the aggregation works correctly
    expected_max_render = max((i % 80) + 1 for i in range(100))

def test_compare_render_benchmarks_both_lists_many_profiles():
    """Test with 100 profiles in both lists."""
    original = [
        RenderProfile(
            component_name="DoubleScale",
            phase="mount" if i % 2 == 0 else "update",
            actual_duration_ms=float(i % 40 + 2),
            base_duration_ms=float((i % 40) + 1),
            render_count=(i % 120) + 1,
        )
        for i in range(100)
    ]
    optimized = [
        RenderProfile(
            component_name="DoubleScale",
            phase="mount" if i % 2 == 0 else "update",
            actual_duration_ms=float(i % 20 + 1),
            base_duration_ms=float((i % 20)),
            render_count=(i % 60) + 1,
        )
        for i in range(100)
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 18.6μs -> 12.8μs (45.2% faster)
    # Verify maximum render counts
    original_max = max((i % 120) + 1 for i in range(100))
    optimized_max = max((i % 60) + 1 for i in range(100))

def test_compare_render_benchmarks_1000_profiles_original():
    """Test with 1000 profiles in original list for scalability."""
    original = [
        RenderProfile(
            component_name="Scalable",
            phase="mount" if i % 2 == 0 else "update",
            actual_duration_ms=float((i % 100) + 1),
            base_duration_ms=float((i % 100)),
            render_count=(i % 500) + 1,
        )
        for i in range(1000)
    ]
    optimized = [
        RenderProfile(
            component_name="Scalable",
            phase="mount",
            actual_duration_ms=50.0,
            base_duration_ms=49.0,
            render_count=250,
        )
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 66.9μs -> 51.0μs (31.3% faster)

def test_compare_render_benchmarks_1000_profiles_optimized():
    """Test with 1000 profiles in optimized list for scalability."""
    original = [
        RenderProfile(
            component_name="ScalableOpt",
            phase="mount",
            actual_duration_ms=100.0,
            base_duration_ms=98.0,
            render_count=500,
        )
    ]
    optimized = [
        RenderProfile(
            component_name="ScalableOpt",
            phase="mount" if i % 2 == 0 else "update",
            actual_duration_ms=float((i % 50) + 1),
            base_duration_ms=float((i % 50)),
            render_count=(i % 250) + 1,
        )
        for i in range(1000)
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 66.2μs -> 47.3μs (40.0% faster)

def test_compare_render_benchmarks_1000_profiles_both_lists():
    """Test with 1000 profiles in both lists for scalability."""
    original = [
        RenderProfile(
            component_name="FullScale",
            phase="mount" if i % 2 == 0 else "update",
            actual_duration_ms=float((i % 75) + 3),
            base_duration_ms=float((i % 75) + 2),
            render_count=(i % 300) + 1,
        )
        for i in range(1000)
    ]
    optimized = [
        RenderProfile(
            component_name="FullScale",
            phase="mount" if i % 2 == 0 else "update",
            actual_duration_ms=float((i % 40) + 1),
            base_duration_ms=float((i % 40)),
            render_count=(i % 150) + 1,
        )
        for i in range(1000)
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 126μs -> 92.0μs (37.6% faster)

def test_compare_render_benchmarks_identical_profiles():
    """Test comparison when original and optimized are identical."""
    profiles = [
        RenderProfile(
            component_name="Identical",
            phase="mount",
            actual_duration_ms=7.5,
            base_duration_ms=6.5,
            render_count=5,
        ),
        RenderProfile(
            component_name="Identical",
            phase="update",
            actual_duration_ms=4.5,
            base_duration_ms=3.5,
            render_count=10,
        ),
    ]
    codeflash_output = compare_render_benchmarks(profiles, profiles); result = codeflash_output # 6.00μs -> 2.90μs (107% faster)

def test_compare_render_benchmarks_precision_float_arithmetic():
    """Test floating point precision in average calculations."""
    original = [
        RenderProfile(
            component_name="Precision",
            phase="mount",
            actual_duration_ms=1.1,
            base_duration_ms=1.0,
            render_count=1,
        ),
        RenderProfile(
            component_name="Precision",
            phase="update",
            actual_duration_ms=2.2,
            base_duration_ms=2.0,
            render_count=2,
        ),
        RenderProfile(
            component_name="Precision",
            phase="update",
            actual_duration_ms=3.3,
            base_duration_ms=3.0,
            render_count=3,
        ),
    ]
    optimized = [
        RenderProfile(
            component_name="Precision",
            phase="mount",
            actual_duration_ms=0.5,
            base_duration_ms=0.4,
            render_count=1,
        ),
        RenderProfile(
            component_name="Precision",
            phase="update",
            actual_duration_ms=0.6,
            base_duration_ms=0.5,
            render_count=2,
        ),
    ]
    codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.79μs -> 2.75μs (110% faster)

def test_compare_render_benchmarks_100_identical_profiles():
    """Test with 100 identical profiles in both lists."""
    profiles = [
        RenderProfile(
            component_name="Uniform",
            phase="mount",
            actual_duration_ms=5.0,
            base_duration_ms=4.0,
            render_count=10,
        )
        for _ in range(100)
    ]
    codeflash_output = compare_render_benchmarks(profiles, profiles); result = codeflash_output # 18.3μs -> 10.7μs (70.9% faster)

def test_compare_render_benchmarks_performance_many_iterations():
    """Test performance by creating many different component comparisons."""
    for iteration in range(100):
        original = [
            RenderProfile(
                component_name=f"Component_{iteration}",
                phase="mount",
                actual_duration_ms=5.0 + iteration,
                base_duration_ms=4.0 + iteration,
                render_count=10 + iteration,
            )
        ]
        optimized = [
            RenderProfile(
                component_name=f"Component_{iteration}",
                phase="mount",
                actual_duration_ms=3.0 + iteration,
                base_duration_ms=2.0 + iteration,
                render_count=5 + iteration,
            )
        ]
        codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 265μs -> 131μs (103% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.